home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / program / 522 / okami12 / doc / tricks.doc < prev    next >
Encoding:
Text File  |  1991-04-17  |  26.2 KB  |  815 lines

  1.  
  2.           ===============================================
  3.  
  4. @(#)        OKAMI SHELL VERSION 1.2 - TIPS UND TRICKS
  5.  
  6.           ===============================================
  7.                 Stand: 22.12.90
  8.  
  9.  
  10.         BITTE ERST DIE DATEIEN README UND OKAMI.DOC LESEN!
  11.  
  12. ----------------------------------------------------------------------------
  13. INHALT
  14.  
  15.     Profile
  16.     Aufruf von Programmen
  17.     Benutzung der Shell von Diskette aus
  18.     Beispiel-Shellscripts
  19.         oksave.sh
  20.         e.sh
  21.         showpic.sh
  22.         startprg.sh
  23.     Shell-Funktionen
  24.     Die gemexec-Funktion
  25.     Die screensave-Funktion
  26.     MS-DOS-Gefühle
  27.     C-Shell-Gefühle
  28.     Gulam-Shell und Master
  29.     Die Versionsnummer der Shell
  30.     Diverses
  31.         Trikolor-Bildschirm
  32.         Aufruf vom Desktop
  33.         Zweideutige Kommandonamen
  34.         Compiler-Aufruf
  35.         Ändern von Dateinamen-Extendern
  36.  
  37. ----------------------------------------------------------------------------
  38. PROFILE
  39.  
  40. Ich benutze das folgende Profile zum Konfigurieren der Shell im Festplatten-
  41. betrieb.
  42.  
  43.  
  44.     # Okami-Shell - System-Profile
  45.  
  46.     TERM=Atari 1040 STF
  47.     # Cursor etwas schneller blinkend
  48.     cursor +bv 12
  49.     # Aktuelles Directory im Prompt anzeigen
  50.     PS1=['$CWD'] ^^^$'  '
  51.     # Pipes auf der Ramdisk
  52.     PIPDIR=g:\
  53.     # Nach Ende der Shell CWD sichern...
  54.     set +s
  55.     # ...und den Cursor abschalten
  56.     trap cursor -v
  57.     # Directories trennen wie in Unix mit Slash
  58.     set +b
  59.     # anmelden als Applikation, stört ja nicht
  60.     gon
  61.     # Word Wrap On
  62.     echo ^033v
  63.  
  64.     # Bidschirm löschen durch viele Leerzeilen, Cursor steht dann unten
  65.     echo "^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n"
  66.  
  67.     # Einschaltmeldung
  68.     echo 
  69.     echo $TERM
  70.     # Versionsnummer der Shell, des TOS und von MiNT (falls vorhanden)
  71.     ver -otM
  72.     echo
  73.     # Ausgabe des Datums des letzten Logins
  74.     cat lastlog 2>NULL:
  75.     echo
  76.     # Ausgabe des freien Speichers
  77.     echo Free RAM: `mem` Bytes
  78.     echo
  79.     # Ausgabe in invertierter Schrift
  80.     echo ^033pType help for command survey.^033q
  81.     echo
  82.  
  83.     # Datum speichern
  84.     echo Last Login: `date` >lastlog
  85.  
  86.     # Letztes CWD zurückholen
  87.     cd `cat wdir`
  88.  
  89.  
  90. Laufwerk G ist eine Ramdisk (Luftschloß 32K), die die einzige Aufgabe hat,
  91. die Pipe-Operationen zu beschleunigen. Dadurch, daß die Pipe auf die Ramdisk
  92. gelegt wird (PIPDIR=g:\), erfolgen alle Pipe-Operationen ohne Platten-
  93. zugriff.
  94. Durch die Einstellung "set +s" wird die Shell veranlaßt, vor dem Programm-
  95. ende das aktuelle Verzeichnis in die Datei $HOME\wdir zu schreiben. Das
  96. Profile benutzt diese Datei, um das aktuelle Verzeichnis wieder auf den
  97. alten Wert einzustellen. So ist man nach dem Start der Shell immer in
  98. dem Verzeichnis, in dem man war, als man die Shell zuletzt verlassen hatte.
  99. Durch die Einstellung "set +x" werden in einer Eingabe alle Slashes (/) in
  100. Backslashes (\) umgeformt, wodurch man die Möglichkeit hat, Dateinamen wie
  101. in Unix einzugeben, also shell/bin/sh.ttp anstatt shell\bin\sh.ttp.
  102. Natürlich erzeugt dann das Kommando
  103.         echo 6/3=2
  104. die Ausgabe
  105.         6\3=2
  106. da alle Slashes umgeformt werden, aber das stört normalerweise nicht.
  107. (den UPN-Rechner stört es übrigens auch nicht, da er den Backslash als
  108. Divisionszeichen versteht. Aus "upn 6 3 /" wird also "upn 6 3 \".)
  109. Außerdem kann man sich in Notfällen mit einfachen Anführungszeichen retten,
  110.     echo '6/3=2'
  111. ergibt also immer
  112.     6/3=2
  113. .
  114.  
  115. ----------------------------------------------------------------------------
  116. AUFRUF VON PROGRAMMEN
  117.  
  118. (Der folgende Abschnitt ist im wesentlichen für Festplattenbenutzer von
  119. Interesse.)
  120.  
  121. Viele Programme gehen davon aus, das sich gewisse Dateien wie z.B. RSCs im
  122. aktuellen Verzeichnis befinden. Um ein solches Kommando zu starten, muß
  123. man also mit cd in das jeweilige Verzeichnis wechseln, was unter Umständen
  124. einige Tipparbeit macht, vor allem bei einer Festplatte. Mit der Okami-
  125. Shell ist es möglich, Programme von überall, also von jedem beliebigen
  126. aktuellen Verzeichnis aus zu starten.
  127. Es sei z.B. GEMTEST.PRG ein Programm, das im Verzeichnis D:\PROG\GEMTEST
  128. steht und eine RSC-Datei aus dem aktuellen Verzeichnis nachladen muß.
  129. Zum Start des Programms müßte man also eingeben
  130.  
  131.     cd d:\prog\gemtest
  132.     gemtest
  133.  
  134. Man kann allerdings auch so vorgehen:
  135. Man erzeugt sich eine Datei namens GEMTEST.SH im Verzeichnis $HOME\bin,
  136. die ungefähr so aussieht:
  137.  
  138.     a=`set -`
  139.     set +x
  140.     d:\prg\gemtest\gemtest.prg
  141.     set $a
  142.     a=
  143.  
  144.  
  145. Zuerst wird der augenblickliche Zustand der Shellflags in der Variablen
  146. a gespeichert, danach wird das Flag x aktiviert. Wenn dieses Flag akti-
  147. viert ist, führt die Shell vor dem Start eines Binärprogramms ein cd in
  148. das Directory aus, in dem sich das Programm befindet. Nach dem Ende des
  149. Programm wird das ursprüngliche Directory wieder restauriert.
  150. Danach wird das Programm gestartet.
  151. Nach Programmende werden die Shell-Flags werden auf den gespeicherten Wert
  152. zurückgesetzt. Danach wird die lokal verwendete Shellvariable a freigegeben.
  153.  
  154. Dadurch, daß sich dieses Shell-Script in dem Verzeichnis $HOME\bin befin-
  155. det, kann es jederzeit durch einfache Eingabe von gemtest aufgerufen 
  156. werden. Man kann es dann auch mit "($HOME\bin\gemtest.sh)" resident als
  157. Shellfunktion laden, dann spart man sich bei jedem Aufruf das Laden des
  158. Scripts.
  159.  
  160. Normalerweise ist das Flag x immer aktiviert. Programme, die sich in einem
  161. der in der Shellvariablen PATH gespeicherten Directories befinden, werden
  162. also immer korrekt gestartet, indem man nur ihren Namen eingibt.
  163.  
  164. ----------------------------------------------------------------------------
  165. BENUTZUNG DER SHELL VON DISKETTE AUS
  166.  
  167. Wenn möglich, sollte man die Shell auf einem schnellen Massespeicher wie
  168. Festplatte oder Ramdisk installieren. Wer die Shell hauptsächlich mit
  169. Disketten benutzt, ärgert sich vermutlich darüber, daß es ziemlich lange
  170. dauert, bis ein falsch eingetipptes Kommando als solches erkannt wird,
  171. da die Shell in allen möglichen Ordnern auf der Diskette nach einer
  172. passenden Datei sucht. Mit den folgenden Einstellungen im Profile kann
  173. die Anzahl dieser Suchoperationen minimiert werden:
  174.  
  175. PATH=.,$HOME\bin
  176. CDPATH=.
  177.  
  178. Wenn man den Programm-Suchpfad auf das aktuelle Directory abkürzt (mit der
  179. Einstellung "PATH=."), werden noch weniger Suchoperationen durchgeführt,
  180. man kann dann allerdings die mitgelieferten externen Kommandos, die sich
  181. in dem Directory $HOME/bin befinden sollten, nicht mehr von überallher
  182. durch den einfachen Kommandonamen aufrufen, sondern muß den ganzen Pfad
  183. angeben (z.B. nicht einfach "format", sondern "$HOME\bin\format.ttp").
  184.  
  185.  
  186. ----------------------------------------------------------------------------
  187. BEISPIEL-SHELLSCRIPTS
  188.  
  189. 1) oksave.sh
  190.  
  191. Ich benutze das folgende Shellscript namens oksave.sh zum Sichern der
  192. Quelldateien der Shell auf Diskette.
  193.  
  194.  
  195.     DEST=$1
  196.     if [ -v DEST ]
  197.       echo Verwendung: oksave Directory
  198.       exit
  199.     fi
  200.     if [ -d $DEST ]
  201.     else
  202.       echo Ein Directory namens $DEST existiert nicht, anlegen? (j/n)
  203.       read b
  204.       if [ -v b ]
  205.         b=n
  206.       fi
  207.       if [ $b = j ]
  208.         mkdir $DEST
  209.         b=
  210.       else
  211.         b=
  212.         exit
  213.       fi
  214.     fi
  215.     echo ^nSichern der Okami-Files auf $DEST ^n
  216.     a=$CWD
  217.     cd e:\okami
  218.     backup -r $DEST <files.lst
  219.     b=`date`
  220.     c=`drvname $DEST`
  221.     echo $b: Okami-Sources gesichert auf $DEST >>oklog
  222.     echo $b: Okami-Sources gesichert auf $DEST >>$c/oklog 
  223.     echo Sichern beendet.
  224.     cd $a
  225.     DEST=
  226.     a=
  227.     b=
  228.     c=
  229.  
  230.  
  231. Das aktuelle Directory wird in einer Shellvariablen gespeichert und dann
  232. auf e:\okami (wo sich die Quellen befinden) umgestellt. Dort befindet
  233. sich ebenfalls eine Datei namens files.lst, in der die Namen aller zu
  234. sichernden Dateien stehen. Diese Datei wird als Eingabe für das Backup-
  235. Kommando benutzt, das alle Dateien auf Diskette sichert, und zwar in
  236. den Ordner, der beim Aufruf des Scripts als Parameter angegeben wird
  237. ($1). Danach werden Datum und Uhrzeit des Sicherns in eine Datei namens
  238. oklog sowohl im Wurzelverzeichnis der Diskette als auch in e:\okami
  239. geschrieben. Diese Datei wächst, d.h. die Angaben werden an die Datei
  240. angehängt, so daß sie die Daten aller Sicherungen enthält. Danach wird
  241. das aktuelle Laufwerk wiederhergestellt und die verwendeten Shellvariablen
  242. freigegeben.
  243. Hier ein Auszug aus der Datei files.lst:
  244.  
  245.  
  246.     # Okami-Shell-Dateien zum Sichern auf Diskette
  247.     # Quellen
  248.     sh.c
  249.     cmds.c
  250.     cmds2.c
  251.     utl.c
  252.     utl2.c
  253.     okami.h
  254.     okext.h
  255.     # ausführbare Dateien
  256.     sh.ttp
  257.     msh.prg
  258.     gem.prg
  259.  
  260.  
  261. 2) e.sh
  262.  
  263. Das Shellscript e.sh dient zum Aufruf des Editors. Das Editorprogramm be-
  264. findet sich in der Datei $HOME\bin\editor.prg. Durch die Verwendung dieses
  265. Shellscripts ist es möglich, irgendwo im Dateisystem den Editor für irgend-
  266. eine Datei aufzurufen.
  267.  
  268.  
  269.     FILE=$*
  270.     if [ -v FILE ]
  271.     then
  272.       FILE=$EFILE
  273.     fi
  274.     FILE=`fullname $FILE`
  275.     $HOME\bin\editor.prg $FILE
  276.     EFILE=$FILE
  277.     FILE=
  278.  
  279.  
  280. Der Name der zu editerenden Datei wird dem Script als Parameter übergeben.
  281. Die Zeile "FILE=`fullname $FILE`" erzeugt in der Variablen FILE
  282. den absoluten Dateinamen, der dem Editorprogramm als Parameter übergeben
  283. wird.
  284.  
  285. Wenn dieses Script ohne Parameter aufgerufen wird, so wird der in der Shell-
  286. variablen EFILE gespeicherte Dateiname benutzt. In dieser Variablen wird
  287. nach jedem Editoraufruf der jeweilige Dateiname gespeichert, so daß man,
  288. wenn man dieselbe Datei mehrmals hintereinander editieren möchte, den Datei-
  289. namen nur einmal angeben muß:
  290.         e datei.txt                     editieren von datei.txt
  291.         e datei2.txt                    editieren von datei2.txt
  292.         e                               ebenfalls datei2.txt
  293.  
  294. Ggfs. muß man dieses Script noch erweitern, um dem Editor mehrere Parameter
  295. zu übergeben (für den Micro-Emacs z.B. den Namen der Konfigurationsdatei o.ä.).
  296.  
  297.  
  298. 3) showpic.sh
  299.  
  300. Dieses Script zeigt, wie man die Shell programmieren kann. Es dient dazu,
  301. Bilddateien, die im Bitmap-Screenformat abgespeichert wurden (Dateilänge
  302. >32000 Bytes), zu laden und anzuzeigen. Es gehört zum Lieferumfang der
  303. Shell, die Bedienungsanleitung befindet sich in commands.doc.
  304.  
  305.  
  306.  
  307. 4) startprg.sh
  308.  
  309. Die Idee zu diesem Shellscript stammt von Thomas Behrens aus Eschweiler und
  310. lautet, ein Programm in einer Fileselectbox auszuwählen und dann zu starten.
  311. Dazu genügt eigentlich die folgende Zeile:
  312.     fsel | xargs {}
  313. , wenn man aber den Abbruch-Button der Box abtesten und dem Programm eine
  314. Parameterzeile übergeben will, sollte man folgendes Script benutzen:
  315.  
  316.     FILE=`fsel *.* "" KEY`
  317.     if [ $KEY = 1 ]
  318.     then
  319.       echo "Bitte Kommandozeile eingeben:"
  320.       read CMD
  321.       $FILE $CMD
  322.     fi
  323.     FILE=
  324.     KEY=
  325.     CMD=
  326.  
  327. Beide Lösungen funktionieren übrigens sowohl mit Binärprogrammen als auch
  328. mit Shellscripts.
  329.  
  330. ---------------------------------------------------------------------------
  331. SHELL-FUNKTIONEN
  332.  
  333. Natürlich sollte man alle häufig gebrauchten Shellscripts resident halten,
  334. und zwar als Shellfunktionen. Es ist möglich, ein Shellscript so zu schreiben,
  335. daß es sich beim ersten Aufruf selber als Funktion installiert; bei allen
  336. weiteren Aufrufen wird dann die Funktion benutzt.
  337.  
  338. Sei z.B. folgendes Shellscript in der Datei hallo.sh, also unter dem Namen
  339. hallo aufzurufen:
  340.  
  341.  
  342.     echo Hallo Anwender!
  343.     echo Der freie Speicherplatz beträgt `mem` Bytes.
  344.     echo Der Platz auf Platte C: beträgt
  345.     df C:
  346.  
  347.  
  348. Setzt man nun die Zeilen
  349.         hallo()
  350.         {
  351. an den Beginn und die Zeilen
  352.         }
  353.         hallo
  354. an das Ende dieses Scripts, also so:
  355.  
  356.  
  357.     hallo()
  358.     {
  359.       echo Hallo Anwender!
  360.       echo Der freie Speicherplatz beträgt `mem` Bytes.
  361.       echo Der Platz auf Platte C: beträgt
  362.       df C:
  363.     }
  364.     hallo
  365.  
  366.  
  367. so wird beim Start des Scripts die Shellfunktion hallo installiert, und bei
  368. jedem weiteren Aufruf von hallo wird nicht das Script, sondern die Funktion
  369. aufgerufen. Mit den zwei Zeilen
  370.  
  371.         hallo()
  372.         {}
  373.  
  374. kann man die Funktion wieder aus dem Speicher entfernen.
  375.  
  376.  
  377. Die Shellfunktionen machen übrigens eine alias-Funktion völlig überflüssig,
  378. da sie auch benutzt werden können, um interne Kommandos umzudefinieren: Wer
  379. anstelle von ls lieber ls -C hat, gibt einfach ein
  380.  
  381.         ls()
  382.         {
  383.           !ls -C $*
  384.         }
  385.  
  386. Wer irgendwann das normale ls benutzen will, kann das tun, indem er es als
  387. !ls aufruft.
  388.  
  389. Ebenso helfen Shellfunktionen, Tippfehler zu vermeiden; wer ständig dor
  390. oder dior statt dir tippt, versuche
  391.  
  392.         dior()
  393.         {
  394.           dir $*
  395.         }
  396.  
  397. Mein Unix-Tippfehler-Script enthält mehrere Dutzend Schreibweisen der
  398. häufig benutzten Kommandos wie dir, grep und der Make-Aufrufe xmake,
  399. qmake und remake.
  400.  
  401. Besondere Funktionen haben die vordefinierten (aber vom Anwender vollständig
  402. umdefinierbaren) Shellfunktionen gemexec und screensave, die im folgenden
  403. Abschnitt beschrieben werden.
  404.  
  405. ---------------------------------------------------------------------------
  406. DIE GEMEXEC-FUNKTION
  407.  
  408. Mit der kann man wirklich einiges machen, denn sie gibt dem Anwender die
  409. Möglichkeit, das Verhalten der Shell beim Start von GEM-Programmen frei zu
  410. programmieren. Dabei stehen ihm alle die nicht zu unterschätzenden Funktionen
  411. der Shell zur Verfügung.
  412. Die folgende Version ist eine Erweiterung der in commands.doc angeführten
  413. gemexec-Funktion, die vor dem Start eines GEM-Programms den Bildschirminhalt
  414. speichert und ihn nachher wiederherstellt. Da das 32000 Bytes an lokalen
  415. Speicher braucht, können Leute mit kleinem Speicher folgende Version benutzen,
  416. die den Bildschirm nur dann speichert, wenn die Shellvariable SAVESCR ge-
  417. setzt ist. Wenn diese Variable nicht gesetzt ist, verhält sie sich wie die
  418. Standardversion. Man kann das Speichern also mit
  419.         SAVESCR=1
  420. ein- und mit
  421.         SAVESCR=
  422. wieder ausschalten.
  423.  
  424.     gemexec()
  425.     {
  426.       _=$0
  427.       if [ +v SAVESCR ]
  428.       then
  429.         echo ^033j^c
  430.         getscr
  431.       fi
  432.       cls
  433.       cursor -v
  434.       exec -g $_
  435.       if [ +v SAVESCR ]
  436.       then
  437.         putscr
  438.         putscr -f
  439.         echo ^033k^c
  440.         cursor +v
  441.       else
  442.         cls
  443.       fi
  444.       _=
  445.     }
  446.  
  447.  
  448. ---------------------------------------------------------------------------
  449. DIE SCREENSAVE-FUNKTION
  450.  
  451. Wenn in der Eingabe Control-P gedrückt wird, ruft die Shell die Shellfunktion
  452. screensave auf. In der Voreinstellung wird dadurch die normale Drucker-Hard-
  453. copy ausgelöst (was sinnvoll ist, wenn die Tastenkombination Alt-Help von
  454. einem residenten Programm okkupiert ist), aber durch Ändern der screensave-
  455. Funktion kann der Anwender jede beliebige Operation durch Ctrl-P auslösen
  456. lassen. Die folgenden drei screensave-Funktionen dienen dazu, die Hardcopy
  457. ähnlich dem Snapshot-Programm in eine Datei umzuleiten.
  458.  
  459. Die erste Version fragt den Anwender mit einer Fileselect-Box nach dem Datei-
  460. namen. Diese Funktion geht davon aus, daß gon aktiviert ist.
  461. Alle Versionen stellen während des Speicherns den Cursor auf nichtblinkend
  462. und schalten ihn, wenn die Shell wieder zur Eingabe bereit ist, wieder auf
  463. blinkend zurück. Wer das nicht will, läßt die cursor-Aufrufe weg.
  464.  
  465.     screensave()
  466.     {
  467.       # Cursor nicht blinkend
  468.       cursor -b
  469.       # Bildschirm sichern
  470.       getscr
  471.       # nach einem Dateinamen fragen
  472.       fsel *.pic "" KEY | read FILE
  473.       # Abbruch geklickt?
  474.       if [ $KEY = 1 ]
  475.       then
  476.         # nein, in die Datei speichern
  477.         putscr -s $FILE
  478.       fi
  479.       # Speicher und Variablen freigeben
  480.       putscr -f
  481.       KEY=
  482.       FILE=
  483.       # Cursor wieder blinkend
  484.       cursor +b
  485.     }
  486.  
  487. Die zweite Version verhält sich eher wie das Snapshot-Kommando. Sie baut selber
  488. einen Dateinamen zusammen. Der Dateiname ist "screen.", der Extender eine
  489. laufende Nummer. Der Zähler befindet sich in der Shellvariablen _SCRCOUNT,
  490. aufwärtsgezählt wird mit Hilfe des UPN-Rechners.
  491.  
  492.     screensave()
  493.     {
  494.       cursor -b
  495.       getscr
  496.       if [ -v _SCRCOUNT ]
  497.       then
  498.         # Wenn es die Zählvariable noch nicht gibt, bei 0 anfangen
  499.         _SCRCOUNT=0
  500.       else
  501.         # ansonsten 1 addieren.
  502.         upn %ld $_SCRCOUNT ++ | read _SCRCOUNT
  503.         # Das Ergebnis lassen wir nicht auf dem Stack rumliegen...
  504.         upn pop
  505.       fi
  506.       # wie oben.
  507.       putscr -s screen.$_SCRCOUNT
  508.       putscr -f
  509.       cursor +b
  510.       FILE=
  511.     }
  512.  
  513. Die dritte Version fragt den Anwender, ob er die Hardcopy in eine Datei oder
  514. auf den Drucker haben möchte.
  515.  
  516.     screensave()
  517.     {
  518.       # Zuerst den Bildschirmspeicher sichern
  519.       cursor -b
  520.       getscr
  521.       # Dann den Anwender fragen
  522.       echo 'Bildschirm speichern: (D)rucker oder (F)ile?'
  523.       read A
  524.       if [ $A = D ]
  525.       then
  526.         # Druckerausgabe, dazu den Bildschirm wieder so herrichten,
  527.         # wie er vor dem echo war
  528.         putscr
  529.         hardcopy
  530.       fi
  531.       if [ $A = F ]
  532.         # Datei
  533.         ................. (wie eins der beiden obigen Beispiele)
  534.       fi
  535.       # Speicher freigeben
  536.       putscr -f
  537.       A=
  538.       cursor +b
  539.     }
  540.  
  541. Man kann das natürlich beliebig weit treiben und ein komplettes Menüprogramm
  542. schreiben, daß mit Ctrl-P aufgerufen wird.
  543.  
  544. ---------------------------------------------------------------------------
  545. MS-DOS-GEFÜHLE
  546.  
  547. Die Unverbesserlichen, die sich statt wie in Unix lieber wie in MS-DOS
  548. fühlen wollen und das aktuelle Laufwerk nicht mit
  549.         cd a:
  550. , sondern einfach mit
  551.         a:
  552. einstellen wollen, können sich mit entsprechenden Shellfunktionen helfen.
  553. Setzt man sich folgende Zeilen für jedes angemeldete Laufwert ins Profile:
  554.  
  555.         a:()
  556.         {
  557.           cd a:
  558.         }
  559.         A:()
  560.         {
  561.           cd a:\
  562.         }
  563.  
  564. dann kann man durch Eingabe von a: das aktuelle Laufwerk a: einstellen und
  565. durch Eingabe von A: in Mupfel-Manier ins Rootdirectory von a: wechseln.
  566. Eine Liste der angemeldeten Laufwerke erhält man bekanntlich mit
  567.         df -m
  568. . Natürlich kann man sich diese Funktionen auch in eine eigene Datei, z.B.
  569. msdos.sh, schreiben und diese dann im Profile mit
  570.         . mshdos.sh
  571. aufrufen. Unixfans erstellen außerdem eine Datei namens killmsdos.sh, in
  572. der sie mit den Zeilen
  573.         a:()
  574.         {}
  575.         A:()
  576.         {}
  577. usw. (für jedes vorhandene Laufwerk) die MS-DOS-Funktionen wieder löschen.
  578.  
  579. ---------------------------------------------------------------------------
  580. C-SHELL-GEFÜHLE
  581.  
  582. Wer sich lieber wie in der C-Shell (/bin/csh) fühlt als wie in der Bourne-
  583. Shell, kann sich auch mit Shellfunktionen helfen.
  584. In der C-Shell werden Variablen mit dem set-Kommando gesetzt:
  585.  
  586.     set()
  587.     {
  588.       VAR=$1
  589.       VAL=$2 $3 $4 $5 $6 $7 $8 $9
  590.       $VAR=$VAL
  591.     }
  592.  
  593. Environmentvariablen setzt man man mit setenv.
  594.  
  595.     setenv()
  596.     {
  597.       VAR=$1
  598.       VAL=$2 $3 $4 $5 $6 $7 $8 $9
  599.       $VAR=$VAL
  600.       export $VAL
  601.     }
  602.  
  603.  
  604. ---------------------------------------------------------------------------
  605. GULAM-SHELL UND MASTER
  606.  
  607.  
  608. In manchen Punkten ist die Gulam-Shell unschlagbar, z.B. was den eingebau-
  609. ten Editor und die Regular-Expression-Fähigkeiten (egrep) angeht (im Ernst:
  610. auch unter Unix habe ich egrep noch nie benutzt), in anderen Beziehungen
  611. hat Okami die Nase vorn (z.B. bei den Möglichkeiten von chmod u.a. Von Pipes,
  612. Command Substitution usw. wagt gulam nicht einmal zu träumen.). Man
  613. kann die Gulam-Shell von der Okami-Shell aus aufrufen, dabei werden alle
  614. exportierten Shellvariablen übergeben und können unter Gulam mit setenv
  615. angesehen werden (anders als Okami unterscheidet Gulam zwischen Environment-
  616. und Shell-Variablen).
  617.  
  618. Fast dasselbe gilt für dir kommerzielle Master-Shell, von der mir leider nur
  619. das Referenznahdbuch zur Verfügung stand. Obwohl Master eine Reihe von Fähig-
  620. keiten hat, vor denen Okami sich respektvoll verbeugen muß, z.B. Unix-Filenamen
  621. und Regular Expressions bis auf TOS-Ebene, Links und Locks usw., ist Master
  622. doch in nicht allen Punkten voraus. Die Shellfunktionen von Okami sind dem
  623. alias-System sicherlich in ihrer Flexibilität weit überlegen (programmieren 
  624. Sie mal while und if in ein alias), und Okami hat eine ganze Reihe von in-
  625. ternen Kommandos, die die Programmierung vereinfachen, z.B. basename, test,
  626. getscr/putscr usw., die Master vermissen läßt. Ein gewaltiges Plus für Okami
  627. ist natürlich der Preis: wer direkt bei mir bestellt, zahlt nicht mehr als
  628. zweimal 1,70 für Porto. Außerdem dürfte es schwierig sein, an die Quellen von
  629. Master zu gelangen.
  630.  
  631. Ein objektiver Vergleich der Fähigkeiten von Gulam/Master und Okami findet sich
  632. in der Datei vergl.doc. (Ja, der Vergleich IST objektiv, auch wenn die beiden
  633. dabei etwas schlecht abschneiden. Wer es nicht glaubt, kann sich ja selber mal
  634. hinsetzen und so einen Vergleich anfertigen.)
  635.  
  636. ----------------------------------------------------------------------------
  637. DIE VERSIONSNUMMER DER SHELL
  638.  
  639.     "Was heißt Manta GTE?    - GETUNED EY!!!!!!"
  640.                     (unbekannter Manta-Witz-Erfinder)
  641.  
  642. Damit keine ähnlichen Mutmaßungen über die Bedeutung der Versionsnummer der
  643. Okami-Shell aufkommen, hier die genaue Beschreibung, was selbige uns zu
  644. sagen hat.
  645.  
  646. Die Versionsnummer, die in der Shell-Variablen $VERSION gespeichert ist und
  647. von dem ver-Kommando ausgegeben wird, gibt ziemlich genaue Auskunft über die
  648. vorliegende Version der Shell und ist folgendermaßen aufgebaut:
  649.  
  650.     z.B. "1.2b+ X"
  651.  
  652. 1 : die Hauptnummer (eine Zahl, gefolgt von einem Punkt)
  653.     diese Nummer ändert sich nur unter besonderen Umständen, z.B. größeren
  654.     Umstellungen der Programmstruktur, Bedienung usw. Versionen mit unter-
  655.     schiedlicher Hauptnummer sind nicht unbedingt kompatibel zueinander.
  656.  
  657. 2 : die Versionsnummer (eine Zahl)
  658.     kennzeichnet die laufende Nummer der Shell und ändert sich mit den
  659.     vollständigen (d.h. garantiert vollständig getesteten und dokumen-
  660.     tierten) Versionen, die von Zeit zu Zeit veröffentlicht werden, wenn
  661.     mir mal eine Weile nichts neues einfällt (also nicht allzu häufig).
  662.     Diese Versionen werden über Pd-Versandstellen vertrieben.
  663.     
  664. Alle anderen Angaben treten optional auf:
  665.  
  666. b : die Zwischen-Release-Nummer (ein Kleinbuchstabe)
  667.     kennzeichnet Releases, die zwischen den o.a. Versionen herauskommen.
  668.     Wer seine Shell direkt bestellt, bekommt mit großer Wahrscheinlich-
  669.     keit eine solche Zwischenversion. Sie sind im großen und ganzen
  670.     fehlerfrei und dokumentiert, obwohl das hier nicht so sicher ist wie
  671.     bei den Hauptversionen (die keine Zwischen-Release-Nummern haben).
  672.  
  673. + : die Test-Kennung
  674.     mit dem Pluszeichen werden die Arbeitsversionen gekennzeichnet, die
  675.     normalerweise nicht veröffentlicht werden. Diese Versionen enthalten
  676.     möglicherweise noch Fehler.
  677.  
  678. X : die Erweiterungsspezifikation (ein oder mehrere Großbuchstaben)
  679.     die Großbuchstaben kennzeichnen erweiterte, verkürzte oder konfektio-
  680.     nierte Versionen. Folgende Erweiterungsspezifikationen können auftre-
  681.     ten:
  682.         F    die Version enthält eine höhere Anzahl von Shell-
  683.             funktionen.
  684.         V    die Version enthält eine höhere Anzahl von Shell-
  685.             variablen.
  686.         L    die Version enthält eine höhere Anzahl von ver-
  687.             schachtelbaren while-Ebenen.
  688.         X    die Version enthält sonstige Erweiterungen der
  689.             Kapazität.
  690.         R    die Version ist restriktiv, d.h. sie enthält wesent-
  691.             lich weniger interne Kommandos als die regulären
  692.             Versionen.
  693.         P    bei Programmstart wird das Profile immer geladen,
  694.             außer es wird der Parameter "-" übergeben (die
  695.             regulären Versionen verhalten sich umgekehrt).
  696.         K    die Version ist auf die Wünsche eines bestimmten
  697.             Anwenders konfektioniert.
  698.  
  699. Die zeitliche Reihenfolge der Versionen lautet also:
  700.  
  701. 1.3        Hauptrelease
  702. 1.3+        Arbeitsversion
  703. 1.3a        Zwischenrelease
  704. 1.3a+        Arbeitsversion
  705. 1.3b        Zwischenrelease
  706. 1.3b+        Arbeitsversion
  707. ....
  708. 1.4        Hauptrelease
  709. 1.4+        Arbeitsversion
  710. usw.
  711.  
  712. Eine genauere Analyse der Shell (Anzahl der möglichen Variablen, Shellfunk-
  713. tionen und geschachtelten whiles, maximale Zeilenanzahl des sort-Kommandos,
  714. Länge des History-Puffers, Größe des UPN-Stacks usw.) kann mit dem Kommando
  715. "ver -l" erzeugt werden.
  716.  
  717. ----------------------------------------------------------------------------
  718. DIVERSES
  719.  
  720. Trikolor-Bildschirm:
  721.  
  722. Durch Verwendung des Kommandos
  723.  
  724. scr -b ; cursor +bv 1
  725.  
  726. auf einem Monochrom-Bildschirm blinkt der Cursor so schnell, daß er wie eine
  727. dritte Farbe auf dem Bildschirm wirkt. Dieser Effekt ist jedoch nur bei
  728. dunklem Hintergrund (scr -b) deutlich sichtbar.
  729.  
  730.  
  731. ~~~~~~~~~~~~~~~~~~~
  732. Aufruf vom Desktop:
  733.  
  734. Wenn man sh.ttp vom Desktop aufruft und eine Kommandozeile eingibt, die
  735. von der Shell ausgeführt werden soll, so erscheint nach der Ausführung
  736. dieser Kommandos wieder das Desktop, ohne daß der Anwender Zeit hat,
  737. eventuelle Ausgaben zu lesen.
  738. Um das zu verhindern, kann das read-Kommdando benutzt werden. Um z.B.
  739. für alle angemeldeten Laufwerke die Platzstatistik (mit dem Kommando
  740. df) zu erhalten, klickt man auf sh.ttp und gibt folgende Kommando-
  741. zeile ein:
  742.  
  743. df ; read
  744.  
  745. oder
  746.  
  747. df ; echo Taste: ; read
  748.  
  749. (Die Leerzeichen um die Strichpunkte sind nicht unbedingt notwendig).
  750. Nach der Ausführung von df wartet die Shell auf eine Eingabe (die durch
  751. Druck auf RETURN beendet sein muß). Im zweiten Beispiel wird außerdem
  752. noch der Text "Taste:" ausgegeben.
  753.  
  754.  
  755. ~~~~~~~~~~~~~~~~~~~~~~~~~~
  756. Zweideutige Kommandonamen:
  757.  
  758. Wenn ein Programm denselben Namen wie ein internes Shellkommando hat, dann
  759. kann dieses Programm nicht einfach mit Namen aufgerufen werden. Hat man
  760. z.B. ein Script namens test.sh, dann wird durch Eingabe von "test" nicht
  761. das Script, sondern das interne Kommando "test" aufgerufen. Um das zu ver-
  762. hindern, gibt man den Kommandonamen in Großbuchstaben ein, also "TEST" oder
  763. "Test", dann wird das externe Kommando aufgerufen. Das liegt daran, daß
  764. Groß-Kleinschreibung bei internen Kommandos von Bedeutung ist, bei Datei-
  765. namen und damit bei externen Kommandos aber nicht.
  766.  
  767.  
  768. ~~~~~~~~~~~~~~~~
  769. Compiler-Aufruf:
  770.  
  771. Folgende Zeilen habe ich im Aufrufshellscript für den Compiler:
  772.  
  773.         d=`date`
  774.         echo #define _CMP_DAT "$d" >$INC/cmpdat.h
  775.         d=
  776.  
  777. Dies erzeugt bei jedem Compileraufruf eine Headerdatei namens cmpdat.h
  778. (die Environmentvariable INC speichert den Pfad der Headerdateien), in der
  779. ein Makro namens _CMP_DAT definiert wird, das das aktuelle Datum beinhaltet,
  780. z.B.
  781.  
  782.         #define _CMP_DAT "03.09.1990 19:33:42"
  783.  
  784. Diese Datei in die C-Quellen eingebunden, und man hat in jedem Programm
  785. das individuelle Datum der Erstellung. Das Ergebnis kann man sich in der
  786. Okami-Shell mit "ver -c" ansehen.
  787.  
  788.  
  789. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  790. Ändern von Dateinamen-Extendern:
  791.  
  792. Die Kommandos basename, dirname und extname kann man benutzen, um den Extender
  793. einer Datei zu ändern, z.B. um zu einer C-Quelldatei den Namen der zugehörigen
  794. Objektdatei zu ermitteln.
  795.  
  796. Man kann dieses Kommando zusammen mit dirname benutzen, um z.B. zu dem Namen
  797. einer C-Quelldatei den Namen der zugehörigen Objektdatei zu ermitteln.
  798.  
  799.     echo Bitte einen C-Quelldateinamen eingeben:
  800.     read FILE
  801.     EXT=`extname $FILE`
  802.     if [ $EXT != .c ]
  803.     then
  804.       echo Das ist keine C-Quelldatei!
  805.     else
  806.       DIR=`dirname $FILE`
  807.       FILE=`basename $FILE .c`
  808.       echo Die Objektdatei ist $DIR/$FILE.o
  809.     fi
  810.  
  811. Ergibt:
  812.     Bitte einen C-Quelldateinamen eingeben:
  813.     e:/okami/cmds4.c
  814.     Die Objektdatei ist e:/okami/cmds4.o
  815.